import fs from 'fs/promises';
import path from 'path';
import { getSystemRootDir } from './utils';

export interface Diary {
  id: string;
  date: string;
  content: string;
  // 可以根据需要添加更多用户属性
  [key: string]: any;
}

export interface Memory {
  id: string;
  type: string;
  isFolder: boolean;
  title: string;
  titleIsEditing: boolean;
  content: string;
  parentId: string;
  created: string;
  updated: string;
  // 可以根据需要添加更多用户属性
  [key: string]: any;
}


export interface Message {
  role: string;
  content: string;
  // 可以根据需要添加更多用户属性
  [key: string]: any;
}
export interface Session {
  id: string;
  lastUpdated: Date;
  messages: Message[];
  description?: string; // 添加description字段
  // 可以根据需要添加更多用户属性
  [key: string]: any;
}



// 定义实体类型
export type Entity = Memory | Diary | Session;
export type EntityType = 'memorys' | 'diarys' | 'sessions';

export interface StorageData {
  memorys: Memory[];
  diarys: Diary[];
  sessions: Session[];
}

/**
 * 通用文件存储类
 */
export class FileStorage {
  private filePath: string;
  private data: StorageData | null = null;

  constructor(fileName: string = 'storage.json') {
    // 在生产环境中，将文件存储在系统根目录下
    // 在开发环境中，存储在项目目录下
    const env = process.env.NODE_ENV;
    if (env === 'development') {
      this.filePath = path.join(__dirname, "../data/", fileName);
    } else {
      // 生产环境存储在系统根目录下
      const systemRoot = getSystemRootDir();
      this.filePath = path.join(systemRoot,".MemoryData/", fileName);
    }
  }

  /**
   * 初始化存储文件
   */
  async init(): Promise<void> {
    try {
      await fs.access(this.filePath);
    } catch {
      // 文件不存在，创建默认文件
      const defaultData: StorageData = {
        memorys: [],
        diarys: [],
        sessions: []
      };
      await this.writeData(defaultData);
    }
    
    // 加载数据到内存
    await this.loadData();
  }

  /**
   * 从文件读取数据到内存
   */
   async loadData(): Promise<void> {
    try {
      const fileContent = await fs.readFile(this.filePath, 'utf-8');
      this.data = JSON.parse(fileContent);
    } catch (error) {
      console.error('读取存储文件失败:', error);
      // 如果读取失败，使用默认数据
      this.data = {
        memorys: [],
        diarys: [],
        sessions: []
      };
    }
  }

  /**
   * 将内存中的数据写入文件
   */
   async writeData(data: StorageData): Promise<void> {
    try {
      // 确保存储目录存在
      const dirPath = path.dirname(this.filePath);
      await fs.mkdir(dirPath, { recursive: true });
      
      await fs.writeFile(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
    } catch (error) {
      console.error('写入存储文件失败:', error);
      throw error;
    }
  }

  /**
   * 获取所有数据
   */
  async getAll(): Promise<StorageData> {
    if (!this.data) {
      await this.loadData();
    }
    return this.data as StorageData;
  }

  /**
   * 获取指定类型的实体列表
   * @param entityType 实体类型
   */
  async getEntities<T extends Entity>(entityType: EntityType): Promise<T[]> {
    const data = await this.getAll();
    return data[entityType] as T[];
  }

  /**
   * 添加实体
   * @param entityType 实体类型
   * @param entity 实体对象
   */
  async addEntity<T extends Entity>(entityType: EntityType, entity: T): Promise<T> {
    const data = await this.getAll();
    (data[entityType] as T[]).push(entity);
    await this.writeData(data);
    return entity;
  }

  /**
   * 根据ID查找实体
   * @param entityType 实体类型
   * @param id 实体ID
   */
  async findEntityById<T extends Entity>(entityType: EntityType, id: string): Promise<T | undefined> {
    const entities = await this.getEntities<T>(entityType);
    return entities.find(entity => entity.id === id);
  }

  /**
   * 根据ID更新实体
   * @param entityType 实体类型
   * @param id 实体ID
   * @param updates 更新内容
   */
  async updateEntity<T extends Entity>(entityType: EntityType, id: string, updates: Partial<T>): Promise<T | null> {
    const data = await this.getAll();
    const entities = data[entityType] as T[];
    const index = entities.findIndex((entity: T) => entity.id === id);
    
    if (index === -1) {
      return null;
    }
    
    entities[index] = { ...entities[index], ...updates };
    await this.writeData(data);
    return entities[index];
  }

  /**
   * 根据ID删除实体
   * @param entityType 实体类型
   * @param id 实体ID
   */
  async deleteEntity(entityType: EntityType, id: string): Promise<boolean> {
    const data = await this.getAll();
    const entities = data[entityType];
    const initialLength = entities.length;
    const newEntities = entities.filter((entity: Entity) => entity.id !== id);
    
    if (newEntities.length === initialLength) {
      return false; // 未找到要删除的实体
    }
    
    // 使用类型断言解决类型问题
    (data as any)[entityType] = newEntities;
    await this.writeData(data);
    return true;
  }

  
}

/**
 * 创建文件存储文件
 * @param env 环境变量
 */
export const createFileStorage = async () => {
  const fileStorage = new FileStorage();
  // 初始化存储文件
  await fileStorage.init();
  console.log(`文件存储已初始化: ${fileStorage}`);
  fileStorage.init();
};